<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js"><span id='Ext-tree-TreePanel-method-constructor'><span id='Ext-tree-TreePanel-cfg-requestMethod'><span id='Ext-tree-TreePanel-cfg-useArrows'><span id='Ext-tree-TreePanel-cfg-pathSeparator'><span id='Ext-tree-TreePanel-cfg-loader'><span id='Ext-tree-TreePanel-cfg-trackMouseOver'><span id='Ext-tree-TreePanel-cfg-selModel'><span id='Ext-tree-TreePanel-cfg-singleExpand'><span id='Ext-tree-TreePanel-cfg-animate'><span id='Ext-tree-TreePanel-cfg-hlColor'><span id='Ext-tree-TreePanel-cfg-hlDrop'><span id='Ext-tree-TreePanel-cfg-containerScroll'><span id='Ext-tree-TreePanel-cfg-ddScroll'><span id='Ext-tree-TreePanel-cfg-ddAppendOnly'><span id='Ext-tree-TreePanel-cfg-ddGroup'><span id='Ext-tree-TreePanel-cfg-dropConfig'><span id='Ext-tree-TreePanel-cfg-dragConfig'><span id='Ext-tree-TreePanel-cfg-enableDrop'><span id='Ext-tree-TreePanel-cfg-enableDrag'><span id='Ext-tree-TreePanel-cfg-enableDD'><span id='Ext-tree-TreePanel-cfg-lines'><span id='Ext-tree-TreePanel-cfg-rootVisible'><span id='Ext-tree-TreePanel-cfg-root'><span id='Ext-tree-TreePanel'>/**
</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span> * @class Ext.tree.TreePanel
 * @extends Ext.Panel
 * &lt;p&gt;The TreePanel provides tree-structured UI representation of tree-structured data.&lt;/p&gt;
 * &lt;p&gt;{@link Ext.tree.TreeNode TreeNode}s added to the TreePanel may each contain metadata
 * used by your application in their {@link Ext.tree.TreeNode#attributes attributes} property.&lt;/p&gt;
 * &lt;p&gt;&lt;b&gt;A TreePanel must have a {@link #root} node before it is rendered.&lt;/b&gt; This may either be
 * specified using the {@link #root} config option, or using the {@link #setRootNode} method.
 * &lt;p&gt;An example of tree rendered to an existing div:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
var tree = new Ext.tree.TreePanel({
    renderTo: 'tree-div',
    useArrows: true,
    autoScroll: true,
    animate: true,
    enableDD: true,
    containerScroll: true,
    border: false,
    // auto create TreeLoader
    dataUrl: 'get-nodes.php',

    root: {
        nodeType: 'async',
        text: 'Ext JS',
        draggable: false,
        id: 'source'
    }
});

tree.getRootNode().expand();
 * &lt;/code&gt;&lt;/pre&gt;
 * &lt;p&gt;The example above would work with a data packet similar to this:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
[{
    &quot;text&quot;: &quot;adapter&quot;,
    &quot;id&quot;: &quot;source\/adapter&quot;,
    &quot;cls&quot;: &quot;folder&quot;
}, {
    &quot;text&quot;: &quot;dd&quot;,
    &quot;id&quot;: &quot;source\/dd&quot;,
    &quot;cls&quot;: &quot;folder&quot;
}, {
    &quot;text&quot;: &quot;debug.js&quot;,
    &quot;id&quot;: &quot;source\/debug.js&quot;,
    &quot;leaf&quot;: true,
    &quot;cls&quot;: &quot;file&quot;
}]
 * &lt;/code&gt;&lt;/pre&gt;
 * &lt;p&gt;An example of tree within a Viewport:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
new Ext.Viewport({
    layout: 'border',
    items: [{
        region: 'west',
        collapsible: true,
        title: 'Navigation',
        xtype: 'treepanel',
        width: 200,
        autoScroll: true,
        split: true,
        loader: new Ext.tree.TreeLoader(),
        root: new Ext.tree.AsyncTreeNode({
            expanded: true,
            children: [{
                text: 'Menu Option 1',
                leaf: true
            }, {
                text: 'Menu Option 2',
                leaf: true
            }, {
                text: 'Menu Option 3',
                leaf: true
            }]
        }),
        rootVisible: false,
        listeners: {
            click: function(n) {
                Ext.Msg.alert('Navigation Tree Click', 'You clicked: &quot;' + n.attributes.text + '&quot;');
            }
        }
    }, {
        region: 'center',
        xtype: 'tabpanel',
        // remaining code not shown ...
    }]
});
&lt;/code&gt;&lt;/pre&gt;
 *
 * @cfg {Ext.tree.TreeNode} root The root node for the tree.
 * @cfg {Boolean} rootVisible &lt;tt&gt;false&lt;/tt&gt; to hide the root node (defaults to &lt;tt&gt;true&lt;/tt&gt;)
 * @cfg {Boolean} lines &lt;tt&gt;false&lt;/tt&gt; to disable tree lines (defaults to &lt;tt&gt;true&lt;/tt&gt;)
 * @cfg {Boolean} enableDD &lt;tt&gt;true&lt;/tt&gt; to enable drag and drop
 * @cfg {Boolean} enableDrag &lt;tt&gt;true&lt;/tt&gt; to enable just drag
 * @cfg {Boolean} enableDrop &lt;tt&gt;true&lt;/tt&gt; to enable just drop
 * @cfg {Object} dragConfig Custom config to pass to the {@link Ext.tree.TreeDragZone} instance
 * @cfg {Object} dropConfig Custom config to pass to the {@link Ext.tree.TreeDropZone} instance
 * @cfg {String} ddGroup The DD group this TreePanel belongs to
 * @cfg {Boolean} ddAppendOnly &lt;tt&gt;true&lt;/tt&gt; if the tree should only allow append drops (use for trees which are sorted)
 * @cfg {Boolean} ddScroll &lt;tt&gt;true&lt;/tt&gt; to enable body scrolling
 * @cfg {Boolean} containerScroll &lt;tt&gt;true&lt;/tt&gt; to register this container with ScrollManager
 * @cfg {Boolean} hlDrop &lt;tt&gt;false&lt;/tt&gt; to disable node highlight on drop (defaults to the value of {@link Ext#enableFx})
 * @cfg {String} hlColor The color of the node highlight (defaults to &lt;tt&gt;'C3DAF9'&lt;/tt&gt;)
 * @cfg {Boolean} animate &lt;tt&gt;true&lt;/tt&gt; to enable animated expand/collapse (defaults to the value of {@link Ext#enableFx})
 * @cfg {Boolean} singleExpand &lt;tt&gt;true&lt;/tt&gt; if only 1 node per branch may be expanded
 * @cfg {Object} selModel A tree selection model to use with this TreePanel (defaults to an {@link Ext.tree.DefaultSelectionModel})
 * @cfg {Boolean} trackMouseOver &lt;tt&gt;false&lt;/tt&gt; to disable mouse over highlighting
 * @cfg {Ext.tree.TreeLoader} loader A {@link Ext.tree.TreeLoader} for use with this TreePanel
 * @cfg {String} pathSeparator The token used to separate sub-paths in path strings (defaults to &lt;tt&gt;'/'&lt;/tt&gt;)
 * @cfg {Boolean} useArrows &lt;tt&gt;true&lt;/tt&gt; to use Vista-style arrows in the tree (defaults to &lt;tt&gt;false&lt;/tt&gt;)
 * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}).
 *
 * @constructor
 * @param {Object} config
 * @xtype treepanel
 */
Ext.tree.TreePanel = Ext.extend(Ext.Panel, {
<span id='Ext-tree-TreePanel-property-rootVisible'>    rootVisible : true,
</span><span id='Ext-tree-TreePanel-property-animate'>    animate : Ext.enableFx,
</span><span id='Ext-tree-TreePanel-property-lines'>    lines : true,
</span><span id='Ext-tree-TreePanel-property-enableDD'>    enableDD : false,
</span><span id='Ext-tree-TreePanel-property-hlDrop'>    hlDrop : Ext.enableFx,
</span><span id='Ext-tree-TreePanel-property-pathSeparator'>    pathSeparator : '/',
</span>
<span id='Ext-tree-TreePanel-cfg-bubbleEvents'>    /**
</span>     * @cfg {Array} bubbleEvents
     * &lt;p&gt;An array of events that, when fired, should be bubbled to any parent container.
     * See {@link Ext.util.Observable#enableBubble}.
     * Defaults to &lt;tt&gt;[]&lt;/tt&gt;.
     */
    bubbleEvents : [],

<span id='Ext-tree-TreePanel-method-initComponent'>    initComponent : function(){
</span>        Ext.tree.TreePanel.superclass.initComponent.call(this);

        if(!this.eventModel){
            this.eventModel = new Ext.tree.TreeEventModel(this);
        }

        // initialize the loader
        var l = this.loader;
        if(!l){
            l = new Ext.tree.TreeLoader({
                dataUrl: this.dataUrl,
                requestMethod: this.requestMethod
            });
        }else if(Ext.isObject(l) &amp;&amp; !l.load){
            l = new Ext.tree.TreeLoader(l);
        }
        this.loader = l;

        this.nodeHash = {};

<span id='Ext-tree-TreePanel-property-root'>        /**
</span>        * The root node of this tree.
        * @type Ext.tree.TreeNode
        * @property root
        */
        if(this.root){
            var r = this.root;
            delete this.root;
            this.setRootNode(r);
        }


        this.addEvents(

<span id='Ext-tree-TreePanel-event-append'>            /**
</span>            * @event append
            * Fires when a new child node is appended to a node in this tree.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The newly appended node
            * @param {Number} index The index of the newly appended node
            */
           'append',
<span id='Ext-tree-TreePanel-event-remove'>           /**
</span>            * @event remove
            * Fires when a child node is removed from a node in this tree.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The child node removed
            */
           'remove',
<span id='Ext-tree-TreePanel-event-movenode'>           /**
</span>            * @event movenode
            * Fires when a node is moved to a new location in the tree
            * @param {Tree} tree The owner tree
            * @param {Node} node The node moved
            * @param {Node} oldParent The old parent of this node
            * @param {Node} newParent The new parent of this node
            * @param {Number} index The index it was moved to
            */
           'movenode',
<span id='Ext-tree-TreePanel-event-insert'>           /**
</span>            * @event insert
            * Fires when a new child node is inserted in a node in this tree.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The child node inserted
            * @param {Node} refNode The child node the node was inserted before
            */
           'insert',
<span id='Ext-tree-TreePanel-event-beforeappend'>           /**
</span>            * @event beforeappend
            * Fires before a new child is appended to a node in this tree, return false to cancel the append.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The child node to be appended
            */
           'beforeappend',
<span id='Ext-tree-TreePanel-event-beforeremove'>           /**
</span>            * @event beforeremove
            * Fires before a child is removed from a node in this tree, return false to cancel the remove.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The child node to be removed
            */
           'beforeremove',
<span id='Ext-tree-TreePanel-event-beforemovenode'>           /**
</span>            * @event beforemovenode
            * Fires before a node is moved to a new location in the tree. Return false to cancel the move.
            * @param {Tree} tree The owner tree
            * @param {Node} node The node being moved
            * @param {Node} oldParent The parent of the node
            * @param {Node} newParent The new parent the node is moving to
            * @param {Number} index The index it is being moved to
            */
           'beforemovenode',
<span id='Ext-tree-TreePanel-event-beforeinsert'>           /**
</span>            * @event beforeinsert
            * Fires before a new child is inserted in a node in this tree, return false to cancel the insert.
            * @param {Tree} tree The owner tree
            * @param {Node} parent The parent node
            * @param {Node} node The child node to be inserted
            * @param {Node} refNode The child node the node is being inserted before
            */
            'beforeinsert',

<span id='Ext-tree-TreePanel-event-beforeload'>            /**
</span>            * @event beforeload
            * Fires before a node is loaded, return false to cancel
            * @param {Node} node The node being loaded
            */
            'beforeload',
<span id='Ext-tree-TreePanel-event-load'>            /**
</span>            * @event load
            * Fires when a node is loaded
            * @param {Node} node The node that was loaded
            */
            'load',
<span id='Ext-tree-TreePanel-event-textchange'>            /**
</span>            * @event textchange
            * Fires when the text for a node is changed
            * @param {Node} node The node
            * @param {String} text The new text
            * @param {String} oldText The old text
            */
            'textchange',
<span id='Ext-tree-TreePanel-event-beforeexpandnode'>            /**
</span>            * @event beforeexpandnode
            * Fires before a node is expanded, return false to cancel.
            * @param {Node} node The node
            * @param {Boolean} deep
            * @param {Boolean} anim
            */
            'beforeexpandnode',
<span id='Ext-tree-TreePanel-event-beforecollapsenode'>            /**
</span>            * @event beforecollapsenode
            * Fires before a node is collapsed, return false to cancel.
            * @param {Node} node The node
            * @param {Boolean} deep
            * @param {Boolean} anim
            */
            'beforecollapsenode',
<span id='Ext-tree-TreePanel-event-expandnode'>            /**
</span>            * @event expandnode
            * Fires when a node is expanded
            * @param {Node} node The node
            */
            'expandnode',
<span id='Ext-tree-TreePanel-event-disabledchange'>            /**
</span>            * @event disabledchange
            * Fires when the disabled status of a node changes
            * @param {Node} node The node
            * @param {Boolean} disabled
            */
            'disabledchange',
<span id='Ext-tree-TreePanel-event-collapsenode'>            /**
</span>            * @event collapsenode
            * Fires when a node is collapsed
            * @param {Node} node The node
            */
            'collapsenode',
<span id='Ext-tree-TreePanel-event-beforeclick'>            /**
</span>            * @event beforeclick
            * Fires before click processing on a node. Return false to cancel the default action.
            * @param {Node} node The node
            * @param {Ext.EventObject} e The event object
            */
            'beforeclick',
<span id='Ext-tree-TreePanel-event-click'>            /**
</span>            * @event click
            * Fires when a node is clicked
            * @param {Node} node The node
            * @param {Ext.EventObject} e The event object
            */
            'click',
<span id='Ext-tree-TreePanel-event-containerclick'>            /**
</span>            * @event containerclick
            * Fires when the tree container is clicked
            * @param {Tree} this
            * @param {Ext.EventObject} e The event object
            */
            'containerclick',
<span id='Ext-tree-TreePanel-event-checkchange'>            /**
</span>            * @event checkchange
            * Fires when a node with a checkbox's checked property changes
            * @param {Node} this This node
            * @param {Boolean} checked
            */
            'checkchange',
<span id='Ext-tree-TreePanel-event-beforedblclick'>            /**
</span>            * @event beforedblclick
            * Fires before double click processing on a node. Return false to cancel the default action.
            * @param {Node} node The node
            * @param {Ext.EventObject} e The event object
            */
            'beforedblclick',
<span id='Ext-tree-TreePanel-event-dblclick'>            /**
</span>            * @event dblclick
            * Fires when a node is double clicked
            * @param {Node} node The node
            * @param {Ext.EventObject} e The event object
            */
            'dblclick',
<span id='Ext-tree-TreePanel-event-containerdblclick'>            /**
</span>            * @event containerdblclick
            * Fires when the tree container is double clicked
            * @param {Tree} this
            * @param {Ext.EventObject} e The event object
            */
            'containerdblclick',
<span id='Ext-tree-TreePanel-event-contextmenu'>            /**
</span>            * @event contextmenu
            * Fires when a node is right clicked. To display a context menu in response to this
            * event, first create a Menu object (see {@link Ext.menu.Menu} for details), then add
            * a handler for this event:&lt;pre&gt;&lt;code&gt;
new Ext.tree.TreePanel({
    title: 'My TreePanel',
    root: new Ext.tree.AsyncTreeNode({
        text: 'The Root',
        children: [
            { text: 'Child node 1', leaf: true },
            { text: 'Child node 2', leaf: true }
        ]
    }),
    contextMenu: new Ext.menu.Menu({
        items: [{
            id: 'delete-node',
            text: 'Delete Node'
        }],
        listeners: {
            itemclick: function(item) {
                switch (item.id) {
                    case 'delete-node':
                        var n = item.parentMenu.contextNode;
                        if (n.parentNode) {
                            n.remove();
                        }
                        break;
                }
            }
        }
    }),
    listeners: {
        contextmenu: function(node, e) {
//          Register the context node with the menu so that a Menu Item's handler function can access
//          it via its {@link Ext.menu.BaseItem#parentMenu parentMenu} property.
            node.select();
            var c = node.getOwnerTree().contextMenu;
            c.contextNode = node;
            c.showAt(e.getXY());
        }
    }
});
&lt;/code&gt;&lt;/pre&gt;
            * @param {Node} node The node
            * @param {Ext.EventObject} e The event object
            */
            'contextmenu',
<span id='Ext-tree-TreePanel-event-containercontextmenu'>            /**
</span>            * @event containercontextmenu
            * Fires when the tree container is right clicked
            * @param {Tree} this
            * @param {Ext.EventObject} e The event object
            */
            'containercontextmenu',
<span id='Ext-tree-TreePanel-event-beforechildrenrendered'>            /**
</span>            * @event beforechildrenrendered
            * Fires right before the child nodes for a node are rendered
            * @param {Node} node The node
            */
            'beforechildrenrendered',
<span id='Ext-tree-TreePanel-event-startdrag'>           /**
</span>             * @event startdrag
             * Fires when a node starts being dragged
             * @param {Ext.tree.TreePanel} this
             * @param {Ext.tree.TreeNode} node
             * @param {event} e The raw browser event
             */
            'startdrag',
<span id='Ext-tree-TreePanel-event-enddrag'>            /**
</span>             * @event enddrag
             * Fires when a drag operation is complete
             * @param {Ext.tree.TreePanel} this
             * @param {Ext.tree.TreeNode} node
             * @param {event} e The raw browser event
             */
            'enddrag',
<span id='Ext-tree-TreePanel-event-dragdrop'>            /**
</span>             * @event dragdrop
             * Fires when a dragged node is dropped on a valid DD target
             * @param {Ext.tree.TreePanel} this
             * @param {Ext.tree.TreeNode} node
             * @param {DD} dd The dd it was dropped on
             * @param {event} e The raw browser event
             */
            'dragdrop',
<span id='Ext-tree-TreePanel-event-beforenodedrop'>            /**
</span>             * @event beforenodedrop
             * Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent
             * passed to handlers has the following properties:&lt;br /&gt;
             * &lt;ul style=&quot;padding:5px;padding-left:16px;&quot;&gt;
             * &lt;li&gt;tree - The TreePanel&lt;/li&gt;
             * &lt;li&gt;target - The node being targeted for the drop&lt;/li&gt;
             * &lt;li&gt;data - The drag data from the drag source&lt;/li&gt;
             * &lt;li&gt;point - The point of the drop - append, above or below&lt;/li&gt;
             * &lt;li&gt;source - The drag source&lt;/li&gt;
             * &lt;li&gt;rawEvent - Raw mouse event&lt;/li&gt;
             * &lt;li&gt;dropNode - Drop node(s) provided by the source &lt;b&gt;OR&lt;/b&gt; you can supply node(s)
             * to be inserted by setting them on this object.&lt;/li&gt;
             * &lt;li&gt;cancel - Set this to true to cancel the drop.&lt;/li&gt;
             * &lt;li&gt;dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true
             * will prevent the animated 'repair' from appearing.&lt;/li&gt;
             * &lt;/ul&gt;
             * @param {Object} dropEvent
             */
            'beforenodedrop',
<span id='Ext-tree-TreePanel-event-nodedrop'>            /**
</span>             * @event nodedrop
             * Fires after a DD object is dropped on a node in this tree. The dropEvent
             * passed to handlers has the following properties:&lt;br /&gt;
             * &lt;ul style=&quot;padding:5px;padding-left:16px;&quot;&gt;
             * &lt;li&gt;tree - The TreePanel&lt;/li&gt;
             * &lt;li&gt;target - The node being targeted for the drop&lt;/li&gt;
             * &lt;li&gt;data - The drag data from the drag source&lt;/li&gt;
             * &lt;li&gt;point - The point of the drop - append, above or below&lt;/li&gt;
             * &lt;li&gt;source - The drag source&lt;/li&gt;
             * &lt;li&gt;rawEvent - Raw mouse event&lt;/li&gt;
             * &lt;li&gt;dropNode - Dropped node(s).&lt;/li&gt;
             * &lt;/ul&gt;
             * @param {Object} dropEvent
             */
            'nodedrop',
<span id='Ext-tree-TreePanel-event-nodedragover'>             /**
</span>             * @event nodedragover
             * Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent
             * passed to handlers has the following properties:&lt;br /&gt;
             * &lt;ul style=&quot;padding:5px;padding-left:16px;&quot;&gt;
             * &lt;li&gt;tree - The TreePanel&lt;/li&gt;
             * &lt;li&gt;target - The node being targeted for the drop&lt;/li&gt;
             * &lt;li&gt;data - The drag data from the drag source&lt;/li&gt;
             * &lt;li&gt;point - The point of the drop - append, above or below&lt;/li&gt;
             * &lt;li&gt;source - The drag source&lt;/li&gt;
             * &lt;li&gt;rawEvent - Raw mouse event&lt;/li&gt;
             * &lt;li&gt;dropNode - Drop node(s) provided by the source.&lt;/li&gt;
             * &lt;li&gt;cancel - Set this to true to signal drop not allowed.&lt;/li&gt;
             * &lt;/ul&gt;
             * @param {Object} dragOverEvent
             */
            'nodedragover'
        );
        if(this.singleExpand){
            this.on('beforeexpandnode', this.restrictExpand, this);
        }
    },

<span id='Ext-tree-TreePanel-method-proxyNodeEvent'>    // private
</span>    proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){
        if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){
            ename = ename+'node';
        }
        // args inline for performance while bubbling events
        return this.fireEvent(ename, a1, a2, a3, a4, a5, a6);
    },


<span id='Ext-tree-TreePanel-method-getRootNode'>    /**
</span>     * Returns this root node for this tree
     * @return {Node}
     */
    getRootNode : function(){
        return this.root;
    },

<span id='Ext-tree-TreePanel-method-setRootNode'>    /**
</span>     * Sets the root node for this tree. If the TreePanel has already rendered a root node, the
     * previous root node (and all of its descendants) are destroyed before the new root node is rendered.
     * @param {Node} node
     * @return {Node}
     */
    setRootNode : function(node){
        this.destroyRoot();
        if(!node.render){ // attributes passed
            node = this.loader.createNode(node);
        }
        this.root = node;
        node.ownerTree = this;
        node.isRoot = true;
        this.registerNode(node);
        if(!this.rootVisible){
            var uiP = node.attributes.uiProvider;
            node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node);
        }
        if(this.innerCt){
            this.clearInnerCt();
            this.renderRoot();
        }
        return node;
    },
    
<span id='Ext-tree-TreePanel-method-clearInnerCt'>    clearInnerCt : function(){
</span>        this.innerCt.update('');    
    },
    
<span id='Ext-tree-TreePanel-method-renderRoot'>    // private
</span>    renderRoot : function(){
        this.root.render();
        if(!this.rootVisible){
            this.root.renderChildren();
        }
    },

<span id='Ext-tree-TreePanel-method-getNodeById'>    /**
</span>     * Gets a node in this tree by its id
     * @param {String} id
     * @return {Node}
     */
    getNodeById : function(id){
        return this.nodeHash[id];
    },

<span id='Ext-tree-TreePanel-method-registerNode'>    // private
</span>    registerNode : function(node){
        this.nodeHash[node.id] = node;
    },

<span id='Ext-tree-TreePanel-method-unregisterNode'>    // private
</span>    unregisterNode : function(node){
        delete this.nodeHash[node.id];
    },

<span id='Ext-tree-TreePanel-method-toString'>    // private
</span>    toString : function(){
        return '[Tree'+(this.id?' '+this.id:'')+']';
    },

<span id='Ext-tree-TreePanel-method-restrictExpand'>    // private
</span>    restrictExpand : function(node){
        var p = node.parentNode;
        if(p){
            if(p.expandedChild &amp;&amp; p.expandedChild.parentNode == p){
                p.expandedChild.collapse();
            }
            p.expandedChild = node;
        }
    },

<span id='Ext-tree-TreePanel-method-getChecked'>    /**
</span>     * Retrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. 'id')
     * @param {String} attribute (optional) Defaults to null (return the actual nodes)
     * @param {TreeNode} startNode (optional) The node to start from, defaults to the root
     * @return {Array}
     */
    getChecked : function(a, startNode){
        startNode = startNode || this.root;
        var r = [];
        var f = function(){
            if(this.attributes.checked){
                r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
            }
        };
        startNode.cascade(f);
        return r;
    },

<span id='Ext-tree-TreePanel-method-getLoader'>    /**
</span>     * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel.
     * @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel.
     */
    getLoader : function(){
        return this.loader;
    },

<span id='Ext-tree-TreePanel-method-expandAll'>    /**
</span>     * Expand all nodes
     */
    expandAll : function(){
        this.root.expand(true);
    },

<span id='Ext-tree-TreePanel-method-collapseAll'>    /**
</span>     * Collapse all nodes
     */
    collapseAll : function(){
        this.root.collapse(true);
    },

<span id='Ext-tree-TreePanel-method-getSelectionModel'>    /**
</span>     * Returns the selection model used by this TreePanel.
     * @return {TreeSelectionModel} The selection model used by this TreePanel
     */
    getSelectionModel : function(){
        if(!this.selModel){
            this.selModel = new Ext.tree.DefaultSelectionModel();
        }
        return this.selModel;
    },

<span id='Ext-tree-TreePanel-method-expandPath'>    /**
</span>     * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
     * @param {String} path
     * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
     * @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with
     * (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded.
     */
    expandPath : function(path, attr, callback){
        if(Ext.isEmpty(path)){
            if(callback){
                callback(false, undefined);
            }
            return;
        }
        attr = attr || 'id';
        var keys = path.split(this.pathSeparator);
        var curNode = this.root;
        if(curNode.attributes[attr] != keys[1]){ // invalid root
            if(callback){
                callback(false, null);
            }
            return;
        }
        var index = 1;
        var f = function(){
            if(++index == keys.length){
                if(callback){
                    callback(true, curNode);
                }
                return;
            }
            var c = curNode.findChild(attr, keys[index]);
            if(!c){
                if(callback){
                    callback(false, curNode);
                }
                return;
            }
            curNode = c;
            c.expand(false, false, f);
        };
        curNode.expand(false, false, f);
    },

<span id='Ext-tree-TreePanel-method-selectPath'>    /**
</span>     * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
     * @param {String} path
     * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
     * @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with
     * (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node.
     */
    selectPath : function(path, attr, callback){
        if(Ext.isEmpty(path)){
            if(callback){
                callback(false, undefined);
            }
            return;
        }
        attr = attr || 'id';
        var keys = path.split(this.pathSeparator),
            v = keys.pop();
        if(keys.length &gt; 1){
            var f = function(success, node){
                if(success &amp;&amp; node){
                    var n = node.findChild(attr, v);
                    if(n){
                        n.select();
                        if(callback){
                            callback(true, n);
                        }
                    }else if(callback){
                        callback(false, n);
                    }
                }else{
                    if(callback){
                        callback(false, n);
                    }
                }
            };
            this.expandPath(keys.join(this.pathSeparator), attr, f);
        }else{
            this.root.select();
            if(callback){
                callback(true, this.root);
            }
        }
    },

<span id='Ext-tree-TreePanel-method-getTreeEl'>    /**
</span>     * Returns the underlying Element for this tree
     * @return {Ext.Element} The Element
     */
    getTreeEl : function(){
        return this.body;
    },

<span id='Ext-tree-TreePanel-method-onRender'>    // private
</span>    onRender : function(ct, position){
        Ext.tree.TreePanel.superclass.onRender.call(this, ct, position);
        this.el.addClass('x-tree');
        this.innerCt = this.body.createChild({tag:'ul',
               cls:'x-tree-root-ct ' +
               (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')});
    },

<span id='Ext-tree-TreePanel-method-initEvents'>    // private
</span>    initEvents : function(){
        Ext.tree.TreePanel.superclass.initEvents.call(this);

        if(this.containerScroll){
            Ext.dd.ScrollManager.register(this.body);
        }
        if((this.enableDD || this.enableDrop) &amp;&amp; !this.dropZone){
<span id='Ext-tree-TreePanel-property-dropZone'>           /**
</span>            * The dropZone used by this tree if drop is enabled (see {@link #enableDD} or {@link #enableDrop})
            * @property dropZone
            * @type Ext.tree.TreeDropZone
            */
             this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || {
               ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true
           });
        }
        if((this.enableDD || this.enableDrag) &amp;&amp; !this.dragZone){
<span id='Ext-tree-TreePanel-property-dragZone'>           /**
</span>            * The dragZone used by this tree if drag is enabled (see {@link #enableDD} or {@link #enableDrag})
            * @property dragZone
            * @type Ext.tree.TreeDragZone
            */
            this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || {
               ddGroup: this.ddGroup || 'TreeDD',
               scroll: this.ddScroll
           });
        }
        this.getSelectionModel().init(this);
    },

<span id='Ext-tree-TreePanel-method-afterRender'>    // private
</span>    afterRender : function(){
        Ext.tree.TreePanel.superclass.afterRender.call(this);
        this.renderRoot();
    },

<span id='Ext-tree-TreePanel-method-beforeDestroy'>    beforeDestroy : function(){
</span>        if(this.rendered){
            Ext.dd.ScrollManager.unregister(this.body);
            Ext.destroy(this.dropZone, this.dragZone);
        }
        this.destroyRoot();
        Ext.destroy(this.loader);
        this.nodeHash = this.root = this.loader = null;
        Ext.tree.TreePanel.superclass.beforeDestroy.call(this);
    },
    
<span id='Ext-tree-TreePanel-method-destroyRoot'>    /**
</span>     * Destroy the root node. Not included by itself because we need to pass the silent parameter.
     * @private
     */
    destroyRoot : function(){
        if(this.root &amp;&amp; this.root.destroy){
            this.root.destroy(true);
        }
    }

<span id='Ext-tree-TreePanel-cfg-activeItem'>    /**
</span>     * @cfg {String/Number} activeItem
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-autoDestroy'>    /**
</span>     * @cfg {Boolean} autoDestroy
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-autoLoad'>    /**
</span>     * @cfg {Object/String/Function} autoLoad
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-autoWidth'>    /**
</span>     * @cfg {Boolean} autoWidth
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-bufferResize'>    /**
</span>     * @cfg {Boolean/Number} bufferResize
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-defaultType'>    /**
</span>     * @cfg {String} defaultType
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-defaults'>    /**
</span>     * @cfg {Object} defaults
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-hideBorders'>    /**
</span>     * @cfg {Boolean} hideBorders
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-items'>    /**
</span>     * @cfg {Mixed} items
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-layout'>    /**
</span>     * @cfg {String} layout
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-layoutConfig'>    /**
</span>     * @cfg {Object} layoutConfig
     * @hide
     */
<span id='Ext-tree-TreePanel-cfg-monitorResize'>    /**
</span>     * @cfg {Boolean} monitorResize
     * @hide
     */
<span id='Ext-tree-TreePanel-property-items'>    /**
</span>     * @property items
     * @hide
     */
<span id='Ext-tree-TreePanel-method-cascade'>    /**
</span>     * @method cascade
     * @hide
     */
<span id='Ext-tree-TreePanel-method-doLayout'>    /**
</span>     * @method doLayout
     * @hide
     */
<span id='Ext-tree-TreePanel-method-find'>    /**
</span>     * @method find
     * @hide
     */
<span id='Ext-tree-TreePanel-method-findBy'>    /**
</span>     * @method findBy
     * @hide
     */
<span id='Ext-tree-TreePanel-method-findById'>    /**
</span>     * @method findById
     * @hide
     */
<span id='Ext-tree-TreePanel-method-findByType'>    /**
</span>     * @method findByType
     * @hide
     */
<span id='Ext-tree-TreePanel-method-getComponent'>    /**
</span>     * @method getComponent
     * @hide
     */
<span id='Ext-tree-TreePanel-method-getLayout'>    /**
</span>     * @method getLayout
     * @hide
     */
<span id='Ext-tree-TreePanel-method-getUpdater'>    /**
</span>     * @method getUpdater
     * @hide
     */
<span id='Ext-tree-TreePanel-method-insert'>    /**
</span>     * @method insert
     * @hide
     */
<span id='Ext-tree-TreePanel-method-load'>    /**
</span>     * @method load
     * @hide
     */
<span id='Ext-tree-TreePanel-method-remove'>    /**
</span>     * @method remove
     * @hide
     */
<span id='Ext-tree-TreePanel-event-add'>    /**
</span>     * @event add
     * @hide
     */
<span id='Ext-tree-TreePanel-method-removeAll'>    /**
</span>     * @method removeAll
     * @hide
     */
<span id='Ext-tree-TreePanel-event-afterLayout'>    /**
</span>     * @event afterLayout
     * @hide
     */
<span id='Ext-tree-TreePanel-event-beforeadd'>    /**
</span>     * @event beforeadd
     * @hide
     */



<span id='Ext-tree-TreePanel-cfg-allowDomMove'>    /**
</span>     * @cfg {String} allowDomMove  @hide
     */
<span id='Ext-tree-TreePanel-cfg-autoEl'>    /**
</span>     * @cfg {String} autoEl @hide
     */
<span id='Ext-tree-TreePanel-cfg-applyTo'>    /**
</span>     * @cfg {String} applyTo  @hide
     */
<span id='Ext-tree-TreePanel-cfg-contentEl'>    /**
</span>     * @cfg {String} contentEl  @hide
     */
<span id='Ext-tree-TreePanel-cfg-data'>    /**
</span>     * @cfg {Mixed} data  @hide
     */
<span id='Ext-tree-TreePanel-cfg-tpl'>    /**
</span>     * @cfg {Mixed} tpl  @hide
     */
<span id='Ext-tree-TreePanel-cfg-tplWriteMode'>    /**
</span>     * @cfg {String} tplWriteMode  @hide
     */
<span id='Ext-tree-TreePanel-cfg-disabledClass'>    /**
</span>     * @cfg {String} disabledClass  @hide
     */
<span id='Ext-tree-TreePanel-cfg-elements'>    /**
</span>     * @cfg {String} elements  @hide
     */
<span id='Ext-tree-TreePanel-cfg-html'>    /**
</span>     * @cfg {String} html  @hide
     */
<span id='Ext-tree-TreePanel-cfg-preventBodyReset'>    /**
</span>     * @cfg {Boolean} preventBodyReset
     * @hide
     */
<span id='Ext-tree-TreePanel-property-disabled'>    /**
</span>     * @property disabled
     * @hide
     */
<span id='Ext-tree-TreePanel-method-applyToMarkup'>    /**
</span>     * @method applyToMarkup
     * @hide
     */
<span id='Ext-tree-TreePanel-method-enable'>    /**
</span>     * @method enable
     * @hide
     */
<span id='Ext-tree-TreePanel-method-disable'>    /**
</span>     * @method disable
     * @hide
     */
<span id='Ext-tree-TreePanel-method-setDisabled'>    /**
</span>     * @method setDisabled
     * @hide
     */
});

Ext.tree.TreePanel.nodeTypes = {};

Ext.reg('treepanel', Ext.tree.TreePanel);</pre>
</body>
</html>
